home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 1.iso / HENSA / MISC / TIERRA.ARC / !Tierra_source_c_parse < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-11  |  10.8 KB  |  408 lines
  1. /* parse.c   6-7-92  parser functions for the Tierra Simulator */
  2. /* Tierra Simulator V3.13: Copyright (c) 1991, 1992 Tom Ray & Virtual Life */
  3.  
  4. #include "license.h"
  5. #include "tierra.h"
  6. #include "extern.h"
  7.  
  8.  
  9. #ifdef MEM_CHK
  10. #include <memcheck.h>
  11. #endif
  12.  
  13. #if INST == 1
  14.  
  15. /* in INST == 1, the array of registers maps into the registers ax, bx, cx, dx
  16.    as follows:  c.re[0] = ax, c.re[1] = bx, c.re[2] = cx, c.re[3] = dx */
  17.  
  18. /*
  19. void SetFlag(ce)
  20. Pcells  ce;
  21. {   ce->c.fl = 1; }
  22. */
  23.  
  24. void pnop(ce) /* do nothing */
  25. Pcells  ce;
  26. {   is.iip = is.dib = 1; }
  27.  
  28. void por1(ce) /* flip low order bit of cx */
  29. Pcells  ce;
  30. {   is.dreg = &(ce->c.re[2]);
  31.     is.dval = ce->c.re[2];
  32.     is.iip = is.dib = 1;
  33.     is.dran = SoupSize;
  34. }
  35.  
  36. void pshl(ce) /* shift left all register of cx */
  37. Pcells  ce;
  38. {   is.dreg = &(ce->c.re[2]);
  39.     is.dval = ce->c.re[2];
  40.     is.iip = is.dib = 1;
  41.     is.dran = SoupSize;
  42. }
  43.  
  44. void pzero(ce) /* cx = 0 */
  45. Pcells  ce;
  46. {   is.dreg = &(ce->c.re[2]);
  47.     is.sval = 0;
  48.     is.iip = is.dib = 1;
  49. }
  50.  
  51. void pif_cz(ce) /* execute next instruction only if cx == 0 */
  52. Pcells  ce;
  53. {   is.sval = ce->c.re[2];
  54.     is.iip = is.dib = 1;
  55. }
  56.  
  57. void psub_ab(ce) /* cx = ax - bx */
  58. Pcells  ce;
  59. {   is.dreg = &(ce->c.re[2]);
  60.     is.sval = ce->c.re[0];
  61.     is.sval2 = -ce->c.re[1];
  62.     is.iip = is.dib = 1;
  63.     is.dran = SoupSize;
  64. }
  65.  
  66. void psub_ac(ce) /* ax = ax - cx */
  67. Pcells  ce;
  68. {   is.dreg = &(ce->c.re[0]);
  69.     is.sval = ce->c.re[0];
  70.     is.sval2 = -ce->c.re[2];
  71.     is.iip = is.dib = 1;
  72.     is.dmod = SoupSize;
  73. }
  74.  
  75. void pinc_a(ce) /* ax++ */
  76. Pcells  ce;
  77. {   is.dreg = &(ce->c.re[0]);
  78.     is.sval = ce->c.re[0];
  79.     is.sval2 = 1;
  80.     is.iip = is.dib = 1;
  81.     is.dmod = SoupSize;
  82. }
  83.  
  84. void pinc_b(ce) /* bx++ */
  85. Pcells  ce;
  86. {   is.dreg = &(ce->c.re[1]);
  87.     is.sval = ce->c.re[1];
  88.     is.sval2 = 1;
  89.     is.iip = is.dib = 1;
  90.     is.dmod = SoupSize;
  91. }
  92.  
  93. void pdec_c(ce) /* cx-- */
  94. Pcells  ce;
  95. {   is.dreg = &(ce->c.re[2]);
  96.     is.sval = ce->c.re[2];
  97.     is.sval2 = -1;
  98.     is.iip = is.dib = 1;
  99.     is.dran = SoupSize;
  100. }
  101.  
  102. void pinc_c(ce) /* cx++ */
  103. Pcells  ce;
  104. {   is.dreg = &(ce->c.re[2]);
  105.     is.sval = ce->c.re[2];
  106.     is.sval2 = 1;
  107.     is.iip = is.dib = 1;
  108.     is.dran = SoupSize;
  109. }
  110.  
  111. void ppushax(ce) /* push ax onto stack */
  112. Pcells  ce;
  113. {   is.sval = ce->c.re[0];
  114.     is.iip = is.dib = 1;
  115. }
  116.  
  117. void ppushbx(ce) /* push bx onto stack */
  118. Pcells  ce;
  119. {   is.sval = ce->c.re[1];
  120.     is.iip = is.dib = 1;
  121. }
  122.  
  123. void ppushcx(ce) /* push cx onto stack */
  124. Pcells  ce;
  125. {   is.sval = ce->c.re[2];
  126.     is.iip = is.dib = 1;
  127. }
  128.  
  129. void ppushdx(ce) /* push dx onto stack */
  130. Pcells  ce;
  131. {   is.sval = ce->c.re[3];
  132.     is.iip = is.dib = 1;
  133. }
  134.  
  135. void ppop_ax(ce) /* pop ax off of stack */
  136. Pcells  ce;
  137. {   is.dreg = &(ce->c.re[0]);
  138.     is.iip = is.dib = 1;
  139.     is.dmod = SoupSize;
  140. }
  141.  
  142. void ppop_bx(ce) /* pop bx off of stack */
  143. Pcells  ce;
  144. {   is.dreg = &(ce->c.re[1]);
  145.     is.iip = is.dib = 1;
  146.     is.dmod = SoupSize;
  147. }
  148.  
  149. void ppop_cx(ce) /* pop cx off of stack */
  150. Pcells  ce;
  151. {   is.dreg = &(ce->c.re[2]);
  152.     is.iip = is.dib = 1;
  153.     is.dran = SoupSize;
  154. }
  155.  
  156. void ppop_dx(ce) /* pop dx off of stack */
  157. Pcells  ce;
  158. {   is.dreg = &(ce->c.re[3]);
  159.     is.iip = is.dib = 1;
  160.     is.dran = SoupSize;
  161. }
  162.  
  163. void ptjmp(ce) /* outward template jump */
  164. Pcells  ce;
  165. {   I32s    a, s = 0;
  166.  
  167.     is.dreg  = &(ce->c.ip); /* destination register for address */
  168.     is.dreg2 = &(ce->c.re[3]); /* destination register for template size */
  169.     a = ad(ce->c.ip + 1); /* a = address of start of template */
  170.     while(1) /* find size of template, s = size */
  171.     {   
  172. #if PLOIDY == 1
  173.     if(soup[ad(a + s)].inst != Nop0 &&
  174.            soup[ad(a + s)].inst != Nop1)
  175. #else /* PLOIDY > 1 */
  176.     if(soup[ad(a + s)][ce->c.tr].inst != Nop0 &&
  177.            soup[ad(a + s)][ce->c.tr].inst != Nop1)
  178. #endif /* PLOIDY > 1 */
  179.             break;
  180.         s++;
  181.     }
  182.     is.sval2 = s;  /* size of template */
  183.     is.dran2 = SoupSize;
  184.     is.dmod  = SoupSize;
  185.     is.dval  = ad(a + s + 1); /* start address for forward search */
  186.     is.dval2 = ad(a - s - 1); /* start address for backward search */
  187.     is.mode  = 0; /* outward jump */
  188.     is.mode2 = 0; /* complementary templates */
  189.     is.iip = 0; is.dib = 1;
  190. }
  191.  
  192. void ptjmpb(ce) /* backward template jump */
  193. Pcells  ce;
  194. {   I32s    a, s = 0;
  195.  
  196.     is.dreg  = &(ce->c.ip); /* destination register for address */
  197.     is.dreg2 = &(ce->c.re[3]); /* destination register for template size */
  198.     a = ad(ce->c.ip + 1); /* a = address of start of template */
  199.     while(1) /* find size of template, s = size */
  200.     {   
  201. #if PLOIDY == 1
  202.     if(soup[ad(a + s)].inst != Nop0 &&
  203.            soup[ad(a + s)].inst != Nop1)
  204. #else /* PLOIDY > 1 */
  205.     if(soup[ad(a + s)][ce->c.tr].inst != Nop0 &&
  206.            soup[ad(a + s)][ce->c.tr].inst != Nop1)
  207. #endif /* PLOIDY > 1 */
  208.             break;
  209.         s++;
  210.     }
  211.     is.sval2 = s;  /* size of template */
  212.     is.dran2 = SoupSize;
  213.     is.dmod  = SoupSize;
  214.     is.dval  = ad(a + s + 1); /* start address for forward search */
  215.     is.dval2 = ad(a - s - 1); /* start address for backward search */
  216.     is.mode  = 2; /* backward jump */
  217.     is.mode2 = 0; /* complementary templates */
  218.     is.iip = 0; is.dib = 1;
  219. }
  220.  
  221. void ptcall(ce) /* push ip to stack, outward template jump */
  222. Pcells  ce;
  223. {   I32s    a, s = 0;
  224.  
  225.     is.dreg  = &(ce->c.ip); /* destination register for address */
  226.     is.dreg2 = &(ce->c.re[3]); /* destination register for template size */
  227.     a = ad(ce->c.ip + 1); /* a = address of start of template */
  228.     while(1) /* find size of template, s = size */
  229.     {
  230. #if PLOIDY == 1
  231.     if(soup[ad(a + s)].inst != Nop0 &&
  232.            soup[ad(a + s)].inst != Nop1)
  233. #else /* PLOIDY > 1 */
  234.     if(soup[ad(a + s)][ce->c.tr].inst != Nop0 &&
  235.            soup[ad(a + s)][ce->c.tr].inst != Nop1)
  236. #endif /* PLOIDY > 1 */
  237.             break;
  238.         s++;
  239.     }
  240.     is.sval  = ce->c.ip + s + 1;    /* address to be pushed onto stack */
  241.     is.sval2 = s;  /* size of template */
  242.     is.dran2 = SoupSize;
  243.     is.dmod  = SoupSize;
  244.     is.dval  = ad(a + s + 1); /* start address for forward search */
  245.     is.dval2 = ad(a - s - 1); /* start address for backward search */
  246.     is.mode  = 0; /* outward jump */
  247.     is.mode2 = 0; /* complementary templates */
  248.     is.iip = 0; is.dib = 1;
  249. }
  250.  
  251. void pret(ce) /* pop ip from stack */
  252. Pcells  ce;
  253. {   is.dreg = &(ce->c.ip);
  254.     is.iip = 0; is.dib = 1;
  255.     is.dmod = SoupSize;
  256. }
  257.  
  258. void pmov_dc(ce) /* dx = cx */
  259. Pcells  ce;
  260. {   is.dreg = &(ce->c.re[mo(3 + flaw(ce), NUM_REGS)]);
  261.     is.sval = ce->c.re[mo(2 + flaw(ce), NUM_REGS)];
  262.     is.iip = is.dib = 1;
  263.     if (is.dreg == &(ce->c.re[0]) || is.dreg == &(ce->c.re[1]))
  264.         is.dmod = SoupSize;
  265.     else
  266.         is.dran = SoupSize;
  267. }
  268.  
  269. void pmov_ba(ce) /* bx = ax */
  270. Pcells  ce;
  271. {   is.dreg = &(ce->c.re[mo(1 + flaw(ce), NUM_REGS)]);
  272.     is.sval = ce->c.re[mo(0 + flaw(ce), NUM_REGS)];
  273.     is.iip = is.dib = 1;
  274.     if (is.dreg == &(ce->c.re[0]) || is.dreg == &(ce->c.re[1]))
  275.         is.dmod = SoupSize;
  276.     else
  277.         is.dran = SoupSize;
  278. }
  279.  
  280. void pmoviab(ce)
  281. Pcells  ce;
  282. {
  283.     is.dval = ad(ce->c.re[0] + flaw(ce));
  284.     is.sval = ad(ce->c.re[1] + flaw(ce));
  285. #if PLOIDY == 1
  286.     is.dins = &soup[is.dval];
  287.     is.sins = &soup[is.sval];
  288. #else /* PLOIDY > 1 */
  289.     is.dins = &soup[is.dval][ce->c.tr];
  290.     is.sins = &soup[is.sval][ce->c.tr];
  291. #endif /* PLOIDY > 1 */
  292.     is.dtra = is.stra = ce->c.tr;
  293.     is.iip = is.dib = 1;
  294. #ifdef HSEX
  295.     if (ce->d.x_over_addr)
  296.        {
  297.        if ((!ce->d.mov_daught) && (!FindMate(ce)))
  298.           ce->d.x_over_addr = ce->d.mate_addr = 0;
  299.        else UseMate(ce);
  300.        }
  301. #endif
  302. }
  303.  
  304. void padr(ce) /* search outward for template, return address in ax */
  305. Pcells  ce; /* return template size in cx */
  306. {   I32s    a, s = 0;
  307.  
  308.     is.dreg  = &(ce->c.re[0]); /* destination register for address */
  309.     is.dreg2 = &(ce->c.re[2]); /* destination register for template size */
  310.     a = ad(ce->c.ip + 1); /* a = address of start of template */
  311.     while(1) /* find size of template, s = size */
  312.     {
  313. #if PLOIDY == 1
  314.     if(soup[ad(a + s)].inst != Nop0 &&
  315.            soup[ad(a + s)].inst != Nop1)
  316. #else /* PLOIDY > 1 */
  317.     if(soup[ad(a + s)][ce->c.tr].inst != Nop0 &&
  318.            soup[ad(a + s)][ce->c.tr].inst != Nop1)
  319. #endif /* PLOIDY > 1 */
  320.             break;
  321.         s++;
  322.     }
  323.     is.sval2 = s;  /* size of template */
  324.     is.dran2 = SoupSize;
  325.     is.dmod  = SoupSize;
  326.     is.dval  = ad(a + s + 1); /* start address for forward search */
  327.     is.dval2 = ad(a - s - 1); /* start address for backward search */
  328.     is.mode  = 0; /* outward jump */
  329.     is.mode2 = 0; /* complementary templates */
  330.     is.iip = s + 1; is.dib = 1;
  331. }
  332.  
  333. void padrb(ce) /* search backward for template, return address in ax */
  334. Pcells  ce; /* return template size in cx */
  335. {   I32s    a, s = 0;
  336.  
  337.     is.dreg  = &(ce->c.re[0]); /* destination register for address */
  338.     is.dreg2 = &(ce->c.re[2]); /* destination register for template size */
  339.     a = ad(ce->c.ip + 1); /* a = address of start of template */
  340.     while(1) /* find size of template, s = size */
  341.     {
  342. #if PLOIDY == 1
  343.     if(soup[ad(a + s)].inst != Nop0 &&
  344.            soup[ad(a + s)].inst != Nop1)
  345. #else /* PLOIDY > 1 */
  346.     if(soup[ad(a + s)][ce->c.tr].inst != Nop0 &&
  347.            soup[ad(a + s)][ce->c.tr].inst != Nop1)
  348. #endif /* PLOIDY > 1 */
  349.             break;
  350.         s++;
  351.     }
  352.     is.sval2 = s;  /* size of template */
  353.     is.dran2 = SoupSize;
  354.     is.dmod  = SoupSize;
  355.     is.dval  = ad(a + s + 1); /* start address for forward search */
  356.     is.dval2 = ad(a - s - 1); /* start address for backward search */
  357.     is.mode  = 2; /* backward jump */
  358.     is.mode2 = 0; /* complementary templates */
  359.     is.iip = s + 1; is.dib = 1;
  360. }
  361.  
  362. void padrf(ce) /* search forward for template, return address in ax */
  363. Pcells  ce; /* return template size in cx */
  364. {   I32s    a, s = 0;
  365.  
  366.     is.dreg  = &(ce->c.re[0]); /* destination register for address */
  367.     is.dreg2 = &(ce->c.re[2]); /* destination register for template size */
  368.     a = ad(ce->c.ip + 1); /* a = address of start of template */
  369.     while(1) /* find size of template, s = size */
  370.     {
  371. #if PLOIDY == 1
  372.     if(soup[ad(a + s)].inst != Nop0 &&
  373.            soup[ad(a + s)].inst != Nop1)
  374. #else /* PLOIDY > 1 */
  375.     if(soup[ad(a + s)][ce->c.tr].inst != Nop0 &&
  376.            soup[ad(a + s)][ce->c.tr].inst != Nop1)
  377. #endif /* PLOIDY > 1 */
  378.             break;
  379.         s++;
  380.     }
  381.     is.sval2 = s;  /* size of template */
  382.     is.dran2 = SoupSize;
  383.     is.dmod  = SoupSize;
  384.     is.dval  = ad(a + s + 1); /* start address for forward search */
  385.     is.dval2 = ad(a - s - 1); /* start address for backward search */
  386.     is.mode  = 1; /* forward jump */
  387.     is.mode2 = 0; /* complementary templates */
  388.     is.iip = s + 1; is.dib = 1;
  389. }
  390.  
  391. void pmal(ce)  /* allocate space for a new cell */
  392. Pcells  ce;  /* allocate space for a new cell */
  393. {   is.dreg = &(ce->c.re[0]);
  394.     is.sval = ce->c.re[2];
  395.     is.dmod = SoupSize;
  396.     is.dtra = ce->c.tr;
  397.     is.mode = MemModeProt; /* only write privelages works at the moment */
  398.     is.iip = is.dib = 1;
  399. }
  400.  
  401. void pdivide(ce)  /* give life to new cell by puting in queue */
  402. Pcells  ce;
  403. {   is.mode = 2;  /* full division */
  404.     is.iip = is.dib = 1;
  405. }
  406.  
  407. #endif  /* end of INST 1 */
  408.